perm filename APP5[AIM,DBL]1 blob
sn#124710 filedate 1974-10-17 generic text, type T, neo UTF8
00100 .DEVICE XGP
00200 .FONT 1 "FIX25"
00300 .FONT 2 "SIGN57"
00400 .FONT 3 "SHD40"
00500 .FONT 4 "BDI25"
00600 .FONT 5 "NGB30"
00700 .FONT 6 "NGR20"
00800 .PAGE FRAME 53 HIGH 77 WIDE
00900 .TURN ON "↓_π{"
01000 .TURN ON "\" FOR "%"
01100 .MACRO B ⊂ BEGIN VERBATIM GROUP ⊃
01200 .MACRO E ⊂ APART END ⊃
01300 .TABBREAK
01400 .COMPACT
01500 .EVERY FOOTING(\6Fourth Draft .... {DATE},page A5.{IF PAGE = 1 THEN 1 ELSE PAGE},User/PUP6 Dialogue excerpts\*)
01600 .EVERY HEADING(\3BEINGS\*,,\4Doug Lenat\*)
01700 .COUNT PAGE PRINTING "1"
01800 .NEXT PAGE
01900
02000 \2APPENDIX 5. \* \3CF .... DIALOGUE\*
02100 .GROUP SKIP 10
02200
02300 Here are fragments of the dialogue which the user went through with
02400 PUP6 to generate the CF program. Near the front, we entered a
02500 frequent-interrupt mode to show what that is like. For the sake of
02600 example, this same piece was re-run without interrupting. This is
02700 all noted below. As usual, the user's reponses are \4ITALICIZED\*,
02800 and the author's meta-comments are in \5LARGE, BOLD type\*.
02900
00100 .NOFILL
00200
00300 ←\4ENTER(T)\*
00400
00500 USER INTERRUPT LEVEL... \40\*
00600
00700 PUP: (PUP WANTS ANY TASK)
00800
00900
01000 USER: \4(WRITE A PROGRAM WHICH DOES CONCEPT FORMATION)\*
01100
01200 PUP: (PUP IS ABOUT TO WRITE A PROGRAM TO DO (CONCEPT:FORMATION))
01300
01400
01500 PUP: ((C:F CONCEPT:FORMATION C CF) IS THE SET OF PLAUSIBLE NAMES OF (CON
01600 -CEPT FORMATION) WHICH IS AN EXPANSION OF (
01700 CONCEPT:FORMATION))
01800
01900
02000 PUP: (PUP WANTS USER TO TYPE IN NAME FOR (CONCEPT:FORMATION))
02100
02200 I DON'T KNOW ANY NAMES FOR ( CONCEPT:FORMATION), SO YOU'LL HAVE TO
02300 TYPE A BRAND NEW NAME IN TO ME.
02400 USER: \4CF\*
02500
02600 PUP: (PUP AND USER ARE ABLE TO REFER TO (CONCEPT:FORMATION) AS TASK:NAME
02700 WHICH IS CF:1)
02800
02900
03000 PUP: (THE NAME OF THE PROGRAM TO DO (CONCEPT:FORMATION) IS CF:1)
03100
03200 \5*************************************************************
03300 The user interrupts, and switches to a frequent-interrupt mode:\*
03400
03500 :\4NEW:LEVEL(10)\*
03600 USER INTERRUPT LEVEL... (PERMIT:USER:INTERRUPT)
03700 :\4OK\*
03800
03900
04000 INTERRUPT? \4YES
04100 \*REQUEST: \4CH
04200 \*NIL *** CHOOSE:FROM *** (WRITE:PROGRAM SERVE)
04300 \5This last request, CH, asked PUP6 to type out the control history;
04400 who called who, etc. In the current case, this is simply a stack.
04500 The present BEING is CHOOSE:FROM, and it is delimited by asterisks.
04600 It was called by WRITE:PROGRAM which was called by SERVE.\*
04700
04800 REQUEST: \4WHAT
04900 \*(CHOOSE THE BEST BEING FROM THE SET (OBTAIN:USABLE:INFORMATION
05000 USE:INFORMATION FILL:IN:UNDEFINED:SECTION CLARIFY:IMPROBABLE:SITUATION
05100 ADAPT:PRECONCEIVED:FUNCTION FIX:INCORRECT:PIECE ) OF BEINGS)
05200 REQUEST: \4WHY
05300 \*(BECAUSE THE FLOW OF CONTROL OF A PROGRAM MUST BE DETERMINATE)
05400 REQUEST: \4OLDER
05500 \*WRITE:PROGRAM
05600 REQUEST: \4CH
05700 \*(CHOOSE:FROM) *** WRITE:PROGRAM *** (SERVE)
05800 REQUEST: \4WHAT
05900 \*(WRITE A PROGRAM WHICH DOES (CONCEPT:FORMATION))
06000 \5 <notice the effect of saying\* \4OLDER\* \5; questions are now
06100 directed to WRITE:PROGRAM instead of to CHOOSE:FROM.>\*
06200 REQUEST: \4WHY
06300 \*(FUNDAMENTAL DRIVE TO OBEY USER; ALSO, IT IS NECESSARY THAT CODE BE WR
06400 -ITTEN TO DO (CONCEPT:FORMATION) IN ORDER THAT
06500 THE TASK (CONCEPT:FORMATION) MIGHT BE COMPLETED; ALSO, EXAMINE SPEC:WHY)
06600 REQUEST: \4SPEC:WHY
06700 \*(WE CALL THE FIRST BEING WHICH CAN BRING ABOUT THE EFFECT (TYPE OF ((C
06800 -ONCEPT:FORMATION) HAS BEEN STUDIED)))
06900 REQUEST: \4HOW
07000 \*(CREATE SPECIALIZED LISP CODE WHICH WILL DO (CONCEPT:FORMATION))
07100 REQUEST: \4?
07200 \*
07300 YOUR OPTIONS ARE AS FOLLOWS:
07400
07500 QUIT END THE INTERRUPT
07600 BEING PRINT NAME OF CURRENT BEING
07700 DEMONS PRINT SET OF DEMONS CURRENTLY ACTIVE
07800 CONTROL:HISTORY PRINT LIST OF BEINGS IN CONTROL, THE PATH FROM THE
07900 CURRENT BEING BACK TO THE BEGINNING OF THE PROGRAM
08000 OLDER CONSIDER THE BEING WHICH CALLED THE CURRENT ONE
08100 YOUNGER CONSIDER THE BEING WHICH THE CURRENT ONE CALLED
08200 OLDEST CONSIDER THE FIRST BEING IN CONTROL
08300 YOUNGEST CONSIDER THE LAST BEING IN CONTROL
08400 SPEC:WHEN AN EVALUATED VERSION OF 'WHEN'
08500 FAIL END THE INTERRUPT AND CAUSE CURRENT BEING TO FAIL
08600 NEW:LEVEL CHANGE THE USER:INTERRUPT LEVEL
08700
08800 SPEC:WHY PRINT OUT THE SPECIFIC REASON(S) THAT THIS BEING WAS
08900 CALLED. THIS DIFFERS FROM 'WHY' IN SENSE THAT SPEC:WHY IS
09000 THE REASON GIVEN BY THE CALLER, WHERAS WHY IS THE REASON
09100 STORED WITH THE CURRENT BEING PERMANENTLY.
09200
09300
09400
09500 TYPING ONE OF THESE WILL PRINT OUT WRITE:PROGRAM'S ANSWER TO THAT QUESTI
09600 -ON:
09700 (IDEN IMPLICIT:ARGS EXPLICIT:ARGS EXPLICIT:ARGS:CHECK NLAMBDA NON:EVAL:A
09800 -RGS WHAT HOW WHY SPEC:WHY MAIN:EFFECTS MINOR:EFFECTS WHEN META:CODE CO
09900 -MMENTS PRE:REQUISITES CO:REQUISITES POST:REQUISITES DEMONS AFFECTS COM
10000 -PLEXITY: GENERALIZATIONS SPECIALIZATIONS ALTERNATIVES PREDICATE
10100 -DATA:STRUCTURE ENCODABLE INHIBIT:CURRENT:DEMONS FORM:CHANGING)
10200 REQUEST: \4SPEC:WHEN
10300 \*((T IS T SO WE DO ADD IN THE WEIGHT (COND ((MEMBER TASK ABLE:PUP:LIST)
10400 -75) (T 40))
10500 WHICH IN THE CURRENT CASE IS 40;
10600 THE EXPLANATION IS (BECAUSE A PRE:EXISTING ABILITY TO DO ( CON
10700 CEPT:FORMATION) IMPLIES THAT WRITING A NEW
10800 PROGRAM TO ACCOMPLISH IT IS SUPERFLUOUS AND,
10900 CONVERSELY, THE INABILITY TO
11000 DO ( CONCEPT:FORMATION) ABDUCTIVELY
11100 ENCOURAGES US THAT WE ARE ON THE RIGHT TRACK))
11200 ((MEMBER TASK WRITTEN:PROGRAMS:LIST) IS NIL, SO WE DONT ADD IN THE
11300 WEIGHT -80 WHICH IN THE CURRENT CASE IS -80 ;
11400 THE EXPLANATION IS (BECAUSE WE ARE NOT MUCH AFTER EFFICIENCY, AND
11500 IF A PROGRAM ALREADY EXISTS, THEN WE SHOULD USE IT))
11600 ((MEMBER ( PUP IS ABOUT TO WRITE A PROGRAM TO DO (TASK)) AWARE:USER:LIST)
11700 IS NIL SO WE DONT ADD IN THE WEIGHT 70
11800 WHICH IN THE CURRENT CASE IS 70 ;
11900 THE EXPLANATION IS (BECAUSE WE GO BY THE OLD
12000 ENGLISH LEGAL RULE THAT SILENCE SIGNIFIES APPROVAL))
12100 (T IS T SO WE DO ADD IN THE WEIGHT (COND (NEW:INFO:LIST -120)
12200 (T 40)) WHICH IN THE CURRENT CASE IS 40 ;
12300 THE EXPLANATION IS (BECAUSE WE SHOULD USE UP THE NEW INFORMATION BEFORE
12400 WRITING PROGRAMS
12500 ALSO: BECAUSE IF NO NEW INFO IS PRESENT,
12600 THEN WE NEEDN'T FEEL GUILTY ABOUT STARTING TO WRITE
12700 A PROGRAM)))
12800 (THE FINAL WHEN VALUE IS THUS 80)
12900 REQUEST: \4CH
13000 \*(CHOOSE:FROM) *** WRITE:PROGRAM *** (SERVE)
13100 REQUEST: \4OLDER
13200 \*SERVE
13300 REQUEST: \4CH
13400 \*(CHOOSE:FROM WRITE:PROGRAM) *** SERVE *** NIL
13500 REQUEST: \4WHAT
13600 \*(DO ANYTHING THE USER ASKS)
13700 REQUEST: \4WHY
13800 \*(FUNDAMENTAL DRIVE TO SERVE THE USER)
13900 REQUEST: \4HOW
14000 \*(GET A TASK FROM THE USER)
14100 REQUEST: \4QUIT
14200 \*INTERRUPT? \4Y
14300 \*
14400 NO, NO. TYPE YES OR NO ......... INTERRUPT? \4YES
14500 \*REQUEST: \4BEING
14600 \*BETTER
14700 REQUEST: \4WHAT
14800 \*(DECIDE WHICH OF (USE:INFORMATION (QUOTE PGM)) (OBTAIN:USABLE:INFORMAT
14900 -ION (QUOTE PGM)) IS MORE A PROPOS TO TRY)
15000 REQUEST: \4WHY
15100 \*(PUP CAN ONLY TRY AT MOST ONE OF USE:INFORMATION AND OBTAIN:USABLE:INF
15200 -ORMATION AT A TIME)
15300 REQUEST: \4HOW
15400 \*(COMPARE THE WHEN PARTS OF USE:INFORMATION AND OBTAIN:USABLE:INFORMATI
15500 -ON AND, IF NECESSARY, COMPARE THEIR COMPLEXITY
15600 S)
15700 REQUEST: \4COMPLEXITY:
15800 \*(.5 .5 .5 .5 .1)
15900 REQUEST: \4CH
16000 \*NIL *** BETTER *** (CHOOSE:FROM WRITE:PROGRAM SERVE)
16100 REQUEST: \4QUIT
16200 \*INTERRUPT? \4NO
16300 \*INTERRUPT? \4NO
16400 \*INTERRUPT? \4NO
16500 \*INTERRUPT? \4YES
16600 \*REQUEST: \4WHAT
16700 \*(FAST:SATISFY THE SIMPLE SUBGOAL (TYPE OF ((CONCEPT:FORMATION) HAS BEE
16800 -N STUDIED)))
16900 REQUEST: \4HOW
17000 \*(PASS CONTROL TO THE SIMPLEST SUFFICIENT BEING)
17100 REQUEST: \4AFFECTS
17200 \*(((STUDY:TYPE (CONCEPT:FORMATION)) POSSIBLE:CALLED) (TRY:BEING CALLED)
17300 (SORT CALLED) (A:BEING:ORDER CALLED))
17400 REQUEST: \4CH
17500 \*NIL *** SATISFY *** (FILL:IN:UNDEFINED:SECTION CHOOSE:FROM WRITE:PROGR
17600 -AM SERVE)
17700 REQUEST: \4OLDER
17800 \*FILL:IN:UNDEFINED:SECTION
17900 REQUEST: \4WHAT
18000 \*(FILL IN AN UNDEFINED SECTION OF CODE AND ADD IT TO THE PROGRAM PGM)
18100 REQUEST: \4WHY
18200 \*(BECAUSE ALL PIECES OF CODE MUST BE DEFINED OR THE PROGRAM WONT RUN)
18300 REQUEST: \4HOW
18400 \*(CHOOSE THE SIMPLEST UNDEFINED PIECE AND ENCODE IT)
18500 REQUEST: \4CHOICE
18600 \*( CF:1 TYPE OF ( CONCEPT:FORMATION))
18700 REQUEST: \4QUIT
18800 \*INTERRUPT? \4YES
18900 \*REQUEST: \4BEING
19000 \*REINVESTIGATE:DECISION
19100 REQUEST: \4WHAT
19200 \*(RESOLVE THE DECISION
19300 (BOOLEAN (SUBJECT:SPECIFIC BEHAVIOR MAY BE REQUIRED OF CF:1)
19400 AFFECTS (WHETHER PARAMETERS
19500 DESCRIBING AN INDIVIDUAL MUST BE READ IN BY CF:1)
19600 WHEN (BEFORE ANY ROUTINES ARE FINALIZED)
19700 WHY (BECAUSE ANY PROCESSING
19800 ROUTINE MAY HAVE TO DEPEND UPON SOME INDIVIDUAL PARAMETERS)
19900 CONCEPT:FORMATION
20000 BECAUSE (SETINTERSECTION UNDEFINED:SECTION:LIST DOING:PUP:LIST)
20100 IS NOW NONNULL; FIRST TRY TO DEFER IT A LITTLE LONGER)
20200 REQUEST: \4HOW
20300 \*(TRY TO DEFER UNTIL ;ELSE TRY TO RESOLVE IT WITH PRESENT KNOWLEDGE ;EL
20400 -SE ASK THE USER TO RESOLVE IT)
20500 REQUEST: \4QUIT
20600 \*INTERRUPT? \4YES
20700 \*REQUEST: \4CH
20800 \*NIL *** DEFER:DECISION *** (REINVESTIGATE:DECISION FILL:IN:UNDEFINED:S
20900 -ECTION CHOOSE:FROM WRITE:PROGRAM SERVE)
21000 REQUEST: \4QUIT
21100 \*INTERRUPT? \4YES
21200 \*REQUEST: \4CH
21300 \*NIL *** UTILIZE *** (WHEN:NEXT DEFER:DECISION REINVESTIGATE:DECISION F
21400 -ILL:IN:UNDEFINED:SECTION CHOOSE:FROM
21500 WRITE:PROGRAM SERVE)
21600 REQUEST: \4HOW
21700 \*(SEARCH THROUGH NIL FOR APPLICABLE RULES)
21800 REQUEST: \4QUIT
21900 \*INTERRUPT? \4YES
22000 \*REQUEST: \4CH
22100 \*NIL *** RESOLVE:DECISION *** (DEFER:DECISION REINVESTIGATE:DECISION FI
22200 -LL:IN:UNDEFINED:SECTION CHOOSE:FROM
22300 WRITE:PROGRAM SERVE)
22400 REQUEST: \4WHY
22500 \*(AS FAR AS WE KNOW AT THIS INSTANT, THE DECISION (BOOLEAN (SUBJECT:SPE
22600 -CIFIC BEHAVIOR MAY BE REQUIRED OF CF:1) ) CANNOT BE
22700 DEFERRED ANY LONGER)
22800 REQUEST: \4HOW
22900 \*(TRY TO RESOLVE (BOOLEAN (SUBJECT:SPECIFIC BEHAVIOR MAY BE REQUIRED OF
23000 CF:1)) WITH PRESENT KNOWLEDGE; IF THAT FAILS, ASK
23100 THE USER ABOUT IT)
23200 REQUEST: \4QUIT
23300 \*INTERRUPT? \4YES
23400 \*REQUEST: \4CH
23500 \*NIL *** ASK:USER:ABOUT *** (RESOLVE:DECISION DEFER:DECISION REINVESTIG
23600 -ATE:DECISION FILL:IN:UNDEFINED:SECTION
23700 CHOOSE:FROM WRITE:PROGRAM SERVE)
23800 REQUEST: \4WHAT
23900 \*(ASK THE USER TO RESOLVE DECISION ((BOOLEAN (SUBJECT:SPECIFIC BEHAVIOR
24000 MAY BE REQUIRED OF CF:1))
24100 REQUEST: \4WHY
24200 \*(BECAUSE PUP CANNOT RESOLVE IT, BUT MUST AT THIS TIME)
24300 REQUEST: \4QUIT
24400 \*
24500 MOVE CURSOR TO ( CF:1 TYPE OF ( CONCEPT:FORMATION))
24600 PUP: SORRY TO BOTHER YOU, BUT I CAN NO LONGER DEFER THIS BOOLEAN DECISIO
24700 -N:(SUBJECT:SPECIFIC BEHAVIOR MAY BE REQUIRED
24800 OF CF:1)SINCE THE DECISION IS BOOLEAN, JUST ANSWER YES OR NO.
24900 SHOULD I DISCUSS RAMIFICATIONS?\4NO\* \5 If the user answered
25000 affirmatively, copious amounts of data would appear, describing
25100 what this choice is, the effects of each possible answer, why it
25200 can't wait, who wanted this done, and so on. \*
25300
25400 NOW TYPE YOUR ANSWER: \4NO\*
25500
25600 OK, READY TO MOVE ON NOW.
25700
25800
25900 \5Here are a few more direct queries to BEINGS during the trace:\*
26000
26100 REQUEST: \4UNDEFINED:SECTION:LIST
26200 \*(( PARTITION:A:DOMAIN) ( PAD:2 TYPE OF ( PARTITION:A
26300 :DOMAIN)))
26400 REQUEST: \4AWARE:USER:LIST
26500 \*(( THE NAME OF THE PROGRAM TO DO ( CONCEPT:FORMATION) IS C
26600 -F:1) ( PUP AND USER ARE ABLE TO REFER
26700 TO ( CONCEPT:FORMATION) AS TASK:NAME WHICH IS CF:1))
26800 REQUEST: \4(PLUS 2 2)\* \5 Converse to DWIM: we try to understand; if
26900 we can't, THEN we try to EVAL the expression
27000 \*4
27100 REQUEST: \4DEMONS
27200 \*(FRINGE:OF:CONCIOUSNESS:DEMON PSYCHOLOGY:DEMON PROGRAM:WRITING:DEMONS
27300 -DEFERRAL:DEMON REINVESTIGATION:DEMON IDIOM:DEMON
27400 SPECIFICITY:CHECK:DEMON FORGETFUL:USER:DEMON)
27500 THE DEMON STACK IS ((PROGRAM:WRITING:DEMONS DEFERRAL:DEMON REINVESTIGATI
27600 -ON:DEMON IDIOM:DEMON SPECIFICITY:CHECK:DEMON
27700 FORGETFUL:USER:DEMON) (FORGETFUL:USER:DEMON))
27800 REQUEST: \4BEING:STACK
27900 \*(WRITE:PROGRAM SERVE)
28000 REQUEST: \4NEW:LEVEL
28100 \*
28200 HELLO THERE. I AM READY TO START .
28300
28400 HOW OFTEN SHOULD I LET YOU INTERRRUPT ME, TO ASK ME ABOUT WHAT I'M
28500 DOING? TYPE A DIGIT, AS EXPLAINED BELOW:
28600
28700 0 NEVER (ULTIMATE PRODUCTION-RUN MODE)
28800 2 A COUPLE OF TIMES DURING THE COURSE OF WRITING A PROGRAM
28900 4 DURING EACH PHASE OF WRITING A PROGRAM
29000 6 DURING THE WRITING OF EACH NONTRIVIAL SUBFUNCTION OF A PROGRAM
29100 8 DURING EACH PHASE OF WRITING EACH SUBFUNCTION OF A PROGRAM
29200 10 EACH TIME A BEING TRANSFERS CONTROL (ULTIMATE DEBUG MODE)
29300
29400 OK, NOW TYPE A DIGIT... \4NO\*
29500
29600 *** ERROR *** YOU MUST TYPE ONE EVEN INTEGER FROM 0 TO 10
29700 TRY AGAIN:
29800 \4(A C)\*
29900
30000 *** ERROR *** YOU MUST TYPE πNE EVEN INTEGER FROM 0 TO 10
30100 TRY AGAIN:
30200 \48\*
30300 REQUEST: \4QUIT
30400 \*
30500
30600
30700
30800 \5<We now pick up where we interrupted before (line of asterisks,
30900 above) with no more interruptions this time. The line of asterisks
31000 below marks the point corresponding to where we left interrupt-mode.
31100 What just took 4 pages to print now takes 7 lines; if we went through
31200 the entire dialogue in interrupt-mode, it would obscure the synthesis
31300 process.>\*
31400
31500
31600 MOVE CURSOR TO ( CF:1 TYPE OF ( CONCEPT:FORMATION))
31700 PUP: SORRY TO BOTHER YOU, BUT I CAN NO LONGER DEFER THIS BOOLEAN DECISIO
31800 -N:(SUBJECT:SPECIFIC BEHAVIOR MAY BE REQUIRED
31900 OF CF:1)SINCE THE DECISION IS BOOLEAN, JUST ANSWER YES OR NO.
32000 SHOULD I DISCUSS RAMIFICATIONS?\4NO\*
32100
32200 NOW TYPE YOUR ANSWER: \4NO\*
32300
32400 OK, READY TO MOVE ON NOW.
32500
32600 \5**********************************************************
32700
32800 Yes, these few lines above are the same as all the previous pages
32900 of dialogue, but without all the interruptions.\*
33000
33100
33200 MOVE CURSOR TO CF:1
33300
33400
33500 PUP IS NOW GOING TO ENCODE THE PIECE
33600 (TEMPORARILY (PARTITION:A:DOMAIN))
33700
33800
33900 OF THE FUNCTION CF:1 INTO LISP. FUNCTION NAMES WILL
34000 BE QUERIED IN PREORDER, AS NEEDED.
34100
34200
34300 PUP WANTS USER TO TYPE IN NAME FOR ( PARTITION:A:DOMAIN)
34400 I DON'T KNOW ANY NAMES FOR ( PARTITION:A:DOMAIN), SO YOU'LL HAVE TO
34500 TYPE A BRAND NEW NAME IN TO ME.
34600 USER: \4PAD\*
34700
34800 THE NAME CHOSEN IS PAD:2
34900
35000 DRAW A LINE FROM THE FUNCTION CALL NIL OF THE FUNCTION CF:1 TO THIS NEW
35100 PIECE OF CODE, WHICH IS ITS BODY:
35200
35300 (CF:1
35400 (LAMBDA (DUMMY:ARGUMENT:3 DUMMY:ARGUMENT:2 DUMMY:ARGUMENT:1)
35500 (TEMPORARILY (PAD:2))))
35600 (CF:1 redefined) \5 The "piece of code" is now just the META:CODE of
35700 the new BEING CF:1. Other parts have been filled in, so it is no
35800 longer defined as above. The full, long definition contains much
35900 bookkeeping but nothing of relevance to tell the user. \*
36000
36100 MOVE CURSOR TO ( PAD:2 TYPE OF ( PARTITION:A:DOMAIN))
36200 PUP: SORRY TO BOTHER YOU, BUT I CAN NO LONGER DEFER THIS SOMEOF DECISION
36300 :(PARTITION:BY:TAKE:ELE:AND:CLASS
36400 PARTITION:BY:TAKE:CLASS:GET:ELE PARTITION:BY:TAKE:ELE:GET:CLASS)
36500 SINCE THE DECISION IS SOME:OF, TYPE ANY ORDERED SUBSET OF:
36600 (A .... PARTITION:BY:TAKE:ELE:AND:CLASS)
36700 (B .... PARTITION:BY:TAKE:CLASS:GET:ELE)
36800 (C .... PARTITION:BY:TAKE:ELE:GET:CLASS)
36900
37000 FOR EXAMPLE, (B D) WOULD MEAN THAT THE 2ND AND 4TH ITEMS ARE RELEVANT
37100 SHOULD I DISCUSS RAMIFICATIONS?\4NO\*
37200
37300
37400 USER: \4(A C)\*
37500
37600
37700 AT THIS POINT, I ALMOST RECOMMENDED VIRTUAL STRUCTURING, BUT DECIDED
37800 AGAINST IT. THE LIST STRUCTURE WOULD HAVE BEEN DIVIDED INTO THESE
37900 PIECES: (PARTITION:BY:TAKE:ELE:AND:CLASS:PART:OF:NIL
38000 PARTITION:BY:TAKE:ELE:GET:CLASS:PART:OF:NIL)
38100 (I GUESS THAT EACH OF THE ABOVE :NIL-S WOULD GET REPLACED BY SOMETHING L
38200 -IKE ":PARTITION:LIST")
38300
38400
38500 MOVE CURSOR TO PAD:2
38600
38700
38800 PUP IS NOW GOING TO ENCODE THE PIECE
38900 (REPEATEDLY (TAKE:HOLD:OF ELEMENT)
39000 (COND ((IS:OF:TYPE ELEMENT (COMMENT PARTITION:BY:TAKE:ELE:
39100 -AND:CLASS))
39200 (PROGN (TAKE:HOLD:OF NAME:OF:CLASS)
39300 (MODIFY:STRUCTURE NAME:OF:CLASS)))
39400 (T (PROGN (GET:HOLD:OF NAME:OF:CLASS)
39500 (MODIFY:STRUCTURE NAME:OF:CLASS)))))
39600
39700
39800 OF THE FUNCTION PAD:2 INTO LISP. FUNCTION NAMES WILL
39900 BE QUERIED IN PREORDER, AS NEEDED.
40000
40100 \5<There is nothing of interest in asking the user for a name. Henceforth
40200 only the result of the naming process will be printed>\*
40300
40400 PUP WANTS USER TO TYPE IN NAME FOR ( TAKE:HOLD:OF)
40500 THE NAME CHOSEN IS TAKE:HOLD:OF:3
40600
40700 PUP WANTS USER TO TYPE IN NAME FOR ( ELEMENT)
40800 THE NAME CHOSEN IS ELEMENT:4
40900
41000 PUP WANTS USER TO TYPE IN NAME FOR ( IS:OF:TYPE)
41100 THE NAME CHOSEN IS HAS:NAME:5
41200
41300 PUP WANTS USER TO TYPE IN NAME FOR ( ELEMENT)
41400 IS THIS THE SAME AS A ( ELEMENT) WHICH WE'VE ALREADY SEEN AND NAME
41500 -D?
41600
41700 USER: \4YES\*
41800
41900 SINCE ELEMENT:4 IS THE ONLY NAME FOR ( ELEMENT),
42000 AT LEAST AS FAR AS PUP KNOWS RIGHT NOW, PUP ASSUMES THAT IS THE ONE
42100 YOU WANT. AM I RIGHT?
42200 USER: \4YES\*
42300
42400 THE NAME CHOSEN IS ELEMENT:4
42500
42600 PUP WANTS USER TO TYPE IN NAME FOR ( TAKE:HOLD:OF)
42700 THE NAME CHOSEN IS TAKE:HOLD:OF:6
42800
42900 PUP WANTS USER TO TYPE IN NAME FOR ( MODIFY:STRUCTURE)
43000 THE NAME CHOSEN IS MODIFY:STRUCTURE:7
43100
43200 PUP WANTS USER TO TYPE IN NAME FOR ( GET:HOLD:OF)
43300 THE NAME CHOSEN IS GET:HOLD:OF:8
43400
43500 PUP WANTS USER TO TYPE IN NAME FOR ( MODIFY:STRUCTURE)
43600 THE NAME CHOSEN IS MODIFY:STRUCTURE:9
43700
43800 DRAW A LINE FROM THE FUNCTION CALL (PAD:2) OF THE FUNCTION PAD:2 TO THI
43900 -S NEW PIECE OF CODE, WHICH IS ITS BODY:
44000
44100 (PAD:2
44200 (LAMBDA (DUMMY:ARGUMENT:3 DUMMY:ARGUMENT:2 DUMMY:ARGUMENT:1)
44300 (PROG NIL
44400 LABEL:1
44500 (TAKE:HOLD:OF:3 ELEMENT:4)
44600 (COND
44700 ((HAS:NAME:5 ELEMENT:4 (COMMENT PARTITION:BY:TAKE:ELE:AND:CL
44800 -ASS))
44900 (PROGN (TAKE:HOLD:OF:6 NAME:OF:CLASS)
45000 (MODIFY:STRUCTURE:7 NAME:OF:CLASS)))
45100 (T (PROGN (GET:HOLD:OF:8 NAME:OF:CLASS)
45200 (MODIFY:STRUCTURE:9 NAME:OF:CLASS))))
45300 (GO LABEL:1)
45400 (COMMENT INFINITE LOOP IN THIS PROG))))
45500 (PAD:2 redefined)
45600
45700 MOVE CURSOR TO ( ELEMENT:4 TYPE OF ( ELEMENT))
45800 PUP: SORRY TO BOTHER YOU, BUT I CAN NO LONGER DEFER THIS DEFINITION DECI
45900 -SION:(WHAT IS AN ELEMENT)
46000 SINCE THE QUESTION IS ONE OF DEFINITION, PLEASE JUST
46100 TYPE IN THE DEFINITION OF ELEMENT:4
46200 SHOULD I DISCUSS RAMIFICATIONS?\4NO\*
46300
46400 USER: \4(A DESCRIPTION OF A STATIC SCENE)\*
46500
46600
46700 PUP: ((S:S STATIC:SCENE S SS) IS THE SET OF PLAUSIBLE NAMES OF (STATIC S
46800 -CENE) WHICH IS AN EXPANSION OF (STATIC SCENE))
46900
47000
47100 PUP: (PUP WANTS USER TO TYPE IN NAME FOR (STATIC SCENE))
47200 PUP: (PUP AND USER ARE ABLE TO REFER TO (STATIC SCENE) AS TNAME WHICH IS
47300 STATIC:SCENE:10)
47400
47500
47600 DRAW A LINE FROM THE FUNCTION CALL (ELEMENT:4 (COMMENT PARTITION:BY:TAK
47700 -E:ELE:AND:CLASS)) OF THE FUNCTION ELEMENT:4 TO THIS NEW PIECE OF CODE,
47800 WHICH IS ITS BODY:
47900
48000 (ELEMENT:4
48100 (LAMBDA (DUMMY:ARGUMENT:3 DUMMY:ARGUMENT:2 DUMMY:ARGUMENT:1)
48200 (STRUCTURE (OBJECTS SET O)
48300 (CLASS:NAME NAME N)
48400 (STATIC RELATIONS S BETWEEN OBJECTS))))
48500 (ELEMENT:4 redefined)
48600
48700 MOVE CURSOR TO ( HAS:NAME:5 TYPE OF ( IS:OF:TYPE))
48800 PUP: SORRY TO BOTHER YOU, BUT I CAN NO LONGER DEFER THIS DEFINITION DECI
48900 -SION:(HOW DO WE KNOW WHEN THE 'IS:OF:TYPE'
49000 PREDICATE IS TRUE, AND WHEN IT IS FALSE? PUP ASSUMES THAT USER WILL TYPE
49100 IN A LOGICAL SENTENCE WHOSE TRUTH IS EQUIVALENT
49200 TO IT)SINCE THE QUESTION IS ONE OF DEFINITION, PLEASE JUST
49300 TYPE IN THE DEFINITION OF HAS:NAME:5
49400
49500 SINCE THIS IS A PREDICATE, THE EXPRESSION YOU TYPE IN SHOULD BE A
49600 LOGICAL EXPRESSION, WHICH IS TRUE IF ELEMENT:4 IS OF
49700 THE (PARTITION:BY:TAKE:ELE:AND:CLASS) TYPE, AND SHOULD BE FALSE IF IT IS
49800 -NT OF
49900 THAT TYPE.
50000
50100 SHOULD I DISCUSS RAMIFICATIONS?\4NO\*
50200
50300 USER: \4(THE FRONT PART OF ARG1 ISNT ???)\*
50400 (IS ??? A LITERAL CONSTANT (WHOSE VALUE SHOULD BE ITSELF) (REPLY YES OR
50500 -NO, PLEASE) USER...)
50600 \4YES\*
50700
50800 MOVE CURSOR TO HAS:NAME:5
50900
51000
51100 PUP IS NOW GOING TO ENCODE THE PIECE
51200 (NOT (EQUAL (CAR ARG1)
51300 ???))
51400
51500
51600 OF THE FUNCTION HAS:NAME:5 INTO LISP. FUNCTION NAMES WILL
51700 BE QUERIED IN PREORDER, AS NEEDED.
51800
51900 DRAW A LINE FROM THE FUNCTION CALL (HAS:NAME:5 ELEMENT:4 (COMMENT PARTI
52000 -TION:BY:TAKE:ELE:AND:CLASS)) OF THE FUNCTION HAS:NAME:5 TO THIS NEW PI
52100 -ECE OF CODE, WHICH IS ITS BODY:
52200
52300 (HAS:NAME:5
52400 (LAMBDA (ARG1 DUMMY:ARGUMENT:2 DUMMY:ARGUMENT:1)
52500 (COMMENT IN ALL CALLS TO DATE, ARG1 IS INSTANTIATED AS ELEMENT:4)
52600 (NOT (EQUAL (CAR ARG1)
52700 ???))))
52800
52900
53000 (HAS:NAME:5 redefined)
53100
53200 MOVE CURSOR TO ( TAKE:HOLD:OF:3 TYPE OF ( TAKE:HOLD:OF))
53300 PUP: SORRY TO BOTHER YOU, BUT I CAN NO LONGER DEFER THIS DICHOTOMY DECIS
53400 -ION:...
53500
53600 AHA!!!! I'VE RESOLVED IT MYSELF!!! NO NEED TO INTERACT WITH THE SLOW
53700 USER CHANNEL AFTER ALL!!!
53800 (PUP IS ABOUT TO ENCODE AN ASSIGNMENT: (OBJECTS SET O) WILL BE SET TO SO
53900 -ME PART OF ARG1 WHICH IS GOING TO BE
54000 INSTANTIATED DURING THE RUNNING OF THE PROGRAM AS ELEMENT:4 .PUP WANTS A
54100 NAME FOR THIS 'SOME PART OF' FUNCTION.)
54200
54300 PUP WANTS USER TO TYPE IN NAME FOR ( OBJECTS:SET:O)
54400 I DON'T KNOW ANY NAMES FOR ( OBJECTS:SET:O), SO YOU'LL HAVE TO
54500 TYPE A BRAND NEW NAME IN TO ME.
54600 USER: \4ELEMENT:OBJECTS\*
54700
54800 THE NAME CHOSEN IS ELEMENT:OBJECTS:11
54900
55000 PUP WANTS USER TO TYPE IN NAME FOR ( SOME:PART:OF)
55100 THE NAME CHOSEN IS SOME:PART:OF:12
55200 .
55300 .
55400 .
55500
55600 DRAW A LINE FROM THE FUNCTION CALL (TAKE:HOLD:OF:3 ELEMENT:4) OF THE FU
55700 -NCTION TAKE:HOLD:OF:3 TO THIS NEW PIECE OF CODE, WHICH IS ITS BODY:
55800
55900 (TAKE:HOLD:OF:3
56000 (NLAMBDA (ARG1)
56100 (COMMENT IN ALL CALLS TO DATE, ARG1 IS INSTANTIATED AS ELEMENT:4)
56200 (PROGN (PUPRINT (COMMENT READY TO ACCEPT BRAND NEW ELEMENT:4))
56300 (SET ARG1 (PREAD))
56400 (SETQ ELEMENT:OBJECTS:11 (SOME:PART:OF:12 (EVAL ARG1)))
56500 (SETQ ELEMENT:CLASSNAME:13 (SOME:PART:OF:14 (EVAL ARG1)))
56600 (SETQ ELEMENT:RELNS:15 (SOME:PART:OF:16 (EVAL ARG1)))
56700 T)))
56800
56900 (TAKE:HOLD:OF:3 redefined)
57000 (COMMENT NAME:OF:CLASS IS NOT A BEING YET)
57100
57200 MOVE CURSOR TO ( TAKE:HOLD:OF:6 TYPE OF ( TAKE:HOLD:OF))
57300
57400 (THE ASSIGNMENT WHICH SET NAME:OF:CLASS
57500 WAS DONE EARLIER; SHOULD A NEW VALUE OF N
57600 -AME:OF:CLASS BE READ IN AT THIS POINT IN
57700 THE PROGRAM FLOW? USER...)
57800 \4NO\*
57900
58000
58100 MOVE CURSOR TO TAKE:HOLD:OF:6
58200
58300
58400 DRAW A LINE FROM THE FUNCTION CALL (TAKE:HOLD:OF:6 NAME:OF:CLASS) OF TH
58500 -E FUNCTION TAKE:HOLD:OF:6 TO THIS NEW PIECE OF CODE, WHICH IS ITS BODY
58600 :
58700
58800 (TAKE:HOLD:OF:6
58900 (NLAMBDA (ARG1)
59000 (COMMENT IN ALL CALLS TO DATE, ARG1 IS INSTANTIATED AS NAME:OF:CLASS
59100 )
59200 (PROGN (COMMENT NOTHING MUCH TO DO HERE; JUST ONE SIMPLE ASSIGNMENT
59300 -TO AN ALREADY EXISITNG VALUE)
59400 (SET ARG1 OBVIOUS:KNOWN:VALUE:OF:NAME:OF:CLASS))))
59500 (TAKE:HOLD:OF:6 redefined)
59600
59700 MOVE CURSOR TO ( GET:HOLD:OF:8 TYPE OF ( GET:HOLD:OF))
59800 PUP: SORRY TO BOTHER YOU, BUT I CAN NO LONGER DEFER THIS SOMEOF DECISION
59900 :(COMPUTE SEARCH GENERATE:AND:TEST)
60000 SINCE THE DECISION IS SOME:OF, TYPE ANY ORDERED SUBSET OF:
60100 (A .... COMPUTE)
60200 (B .... SEARCH)
60300 (C .... GENERATE:AND:TEST)
60400
60500 USER: \4(B)\*
60600
60700
60800 YOU MUST GIVE ME A LIST OF ALL THE VALUES THAT COULD EVER OCCUR AS
60900 NAMES ON THE LIST STRUCTURE SET:OF:POSSIBLE:NAMES:OF:CLASS
61000 IF THIS ISN'T MEANINGFUL, REPLY NIL.
61100 USER: \4NIL\*
61200
61300 MOVE CURSOR TO ( GET:HOLD:OF:8 TYPE OF ( GET:HOLD:OF))
61400 PUP: SORRY TO BOTHER YOU, BUT I CAN NO LONGER DEFER THIS BOOLEAN DECISIO
61500 -N:(DOES AN ALGORITHM ALREADY EXIST WHICH GETS
61600 PRECISELY NAME:OF:CLASS)SINCE THE DECISION IS BOOLEAN, JUST ANSWER YES O
61700 -R NO.
61800 SHOULD I DISCUSS RAMIFICATIONS?\4NO\*
61900
62000 NOW TYPE YOUR ANSWER: \4NO\*
62100
62200 OK, READY TO MOVE ON NOW.
62300
62400 MOVE CURSOR TO GET:HOLD:OF:8
62500
62600
62700 PUP IS NOW GOING TO ENCODE THE PIECE
62800 (PROGN (FOREACH POSSIBLE:NAME:OF:CLASS IN SET:OF:POSSIBLE:NAMES:OF:CLA
62900 -SS DO (TEST POSSIBLE:NAME:OF:CLASS
63000
63100 (COMMENT FOR SATISFACTION OF GOAL
63200
63300 CRITERIA)))
63400 (PUPRIN1 "
63500 MY GUESS FOR THIS IS ")
63600 (PUPRINT POSSIBLE:NAME:OF:CLASS))
63700
63800
63900 OF THE FUNCTION GET:HOLD:OF:8 INTO LISP. FUNCTION NAMES WILL
64000 BE QUERIED IN PREORDER, AS NEEDED.
64100
64200 PUP WANTS USER TO TYPE IN NAME FOR ( FOREACH)
64300 .
64400 .
64500 .
64600
64700 MOVE CURSOR TO ( FOREACH:17 TYPE OF ( FOREACH))
64800 PUP: SORRY TO BOTHER YOU, BUT I CAN NO LONGER DEFER THIS BOOLEAN DECISIO
64900 -N:(I ASSUME THAT I STOP AFTER EXAMINING ALL
65000 POSSIBLE:NAMES:OF:CLASS IN SET:OF:POSSIBLE:NAMES:OF:CLASS ; DO I ALSO ST
65100 -OP AFTER SOME CONDITION 'C' BECOMES TRUE?)
65200 SINCE THE DECISION IS BOOLEAN, JUST ANSWER YES OR NO.
65300 SHOULD I DISCUSS RAMIFICATIONS?\4NO\*
65400
65500 NOW TYPE YOUR ANSWER: \4YES\*
65600
65700 PLEASE TYPE IN A PREDICATE EQUIVALENT TO THIS UNTIL CONDITION 'C'.
65800 (TYPING IN ] WILL MEAN THAT THE CONDITION IS THAT RESULT:1
65900 IS NONNULL.)
66000 USER: \4(TEST:18 SUCCEEDED)\*
66100
66200 OK, READY TO MOVE ON NOW.
66300
66400 MOVE CURSOR TO FOREACH:17
66500
66600
66700 DRAW A LINE FROM THE FUNCTION CALL (FOREACH:17 POSSIBLE:NAME:OF:CLASS I
66800 -N SET:OF:POSSIBLE:NAMES:OF:CLASS DO (TEST:18 POSSIBLE:NAME:OF:CLASS (C
66900 -OMMENT FOR SATISFACTION OF GOAL CRITERIA))) OF THE FUNCTION FOREACH:17
67000 TO THIS NEW PIECE OF CODE, WHICH IS ITS BODY:
67100
67200 (FOREACH:17
67300 (NLAMBDA (ARG1 DUMMY:ARGUMENT:2 ARG3 DUMMY:ARGUMENT:1 ARG5)
67400 (COMMENT IN ALL CALLS TO DATE, ARG3 IS INSTANTIATED AS SET:OF:POSSIB
67500 -LE:NAMES:OF:CLASS)
67600 (PROGN (COMMENT IN ALL CALLS TO DATE, ARG1 IS BOUND TO POSSIBLE:NAME
67700 :OF:CLASS)
67800 (COMMENT IN ALL CALLS TO DATE, ARG3 IS BOUND TO SET:OF:POSSIB
67900 -LE:NAMES:OF:CLASS)
68000 (COMMENT IN ALL CALLS TO DATE, ARG5 IS BOUND TO (COMMENT TEST
68100 :18 POSSIBLE:NAME:OF:CLASS
68200 (COM
68300 -MENT FOR SATISFACTION OF GOAL CRITERIA)))
68400 (PROG (RESULT:1)
68500 (SETQ EVAL:ARG3 (EVAL ARG3))
68600 LABEL:2
68700 (COND
68800 ((NULL EVAL:ARG3)
68900 (SET ARG1 FAILURE:VALUE)
69000 (RETURN EXHAUSTION:VALUE)))
69100 (SET ARG1 (CAR EVAL:ARG3))
69200 (SETQ EVAL:ARG3 (CDR EVAL:ARG3))
69300 (SETQ RESULT:1 (EVAL ARG5))
69400 (COND
69500 ((NOT (EQUAL RESULT:1 NIL))
69600 (RETURN UNTIL:CONDITION:VALUE))
69700 (T (GO LABEL:2)))
69800 (COMMENT AT THE TIME THAT FOREACH:17 WAS CODED, THE UNT
69900 -IL CONDITION VALUE WAS LEFT UNDEFINED)))))
70000
70100 (FOREACH:17 redefined)
70200
70300 MOVE CURSOR TO ( TEST:18 TYPE OF ( TEST))
70400 PUP: SORRY TO BOTHER YOU, BUT I CAN NO LONGER DEFER THIS BOOLEAN DECISIO
70500 -N:(SHOULD WE IMPLEMENT ERROR RECOVERY IN ANY
70600 FANCY WAY)SINCE THE DECISION IS BOOLEAN, JUST ANSWER YES OR NO.
70700 SHOULD I DISCUSS RAMIFICATIONS?\4NO\*
70800
70900 NOW TYPE YOUR ANSWER: \4NO\*
71000
71100 NOTHING TO DO AT THIS TIME, THEN.
71200
71300 OK, READY TO MOVE ON NOW.
71400
71500 PUP: SORRY TO BOTHER YOU, BUT I CAN NO LONGER DEFER THIS DICHOTOMY DECIS
71600 -ION:(( THE TESTING MAY HAVE THE CHARACTER
71700 OF COMPARING THE OBJECT ( THAT IS, ARG1, ALSO KNOWN AS
71800 ( CADDR ENT1)) WITH SOME DISTINGUISHED OBJECT)
71900 ( TESTING MAY HAVE THE CHARACTER OF LETTING THE OBJECT ( WHI
72000 -CH IS ARG1) COMPETE WITH ITS FELLOW OBJECTS
72100 FOR SUPREMACY)
72200 ABOVE, ARG1 REFERS TO POSSIBLE:NAME:OF:CLASS )
72300
72400 AHA!!!! I'VE RESOLVED IT MYSELF!!! NO NEED TO INTERACT WITH THE SLOW
72500 USER CHANNEL AFTER ALL!!!
72600
72700 MOVE CURSOR TO TEST:18
72800
72900
73000 PUP IS NOW GOING TO ENCODE THE PIECE
73100 (COMPARE ARG1 ELEMENT:4)
73200
73300
73400 OF THE FUNCTION TEST:18 INTO LISP. FUNCTION NAMES WILL
73500 BE QUERIED IN PREORDER, AS NEEDED.
73600
73700 PUP WANTS USER TO TYPE IN NAME FOR ( COMPARE)
73800 .
73900 .
74000 .
74100 DRAW A LINE FROM THE FUNCTION CALL (COMPARE:19 ARG1 ELEMENT:4) OF THE F
74200 -UNCTION COMPARE:19 TO THIS NEW PIECE OF CODE, WHICH IS ITS BODY:
74300
74400 (COMPARE:19
74500 (LAMBDA (ARG1 ARG2)
74600 (COMMENT IN ALL CALLS TO DATE, ARG1 IS INSTANTIATED AS POSSIBLE:NAME
74700 :OF:CLASS)
74800 (COMMENT IN ALL CALLS TO DATE, ARG2 IS INSTANTIATED AS ELEMENT:4)
74900 (PROGN ARG1 ARG2 (COMMENT ARG1 AND ARG2 ARE HERE SIMPLY TO CAUSE PUP
75000 TO STICK IN COMMENTS ABOUT THEIR INSTANTIATION)
75100 (JOIN:23 (COMPARE:24 POSSIBLE:NAME:OF:CLASS:OBJECTS:20 ELEMEN
75200 -T:OBJECTS:11)
75300 (COMPARE:25 POSSIBLE:NAME:OF:CLASS:CLASSNAME:21 ELEM
75400 -ENT:CLASSNAME:13)
75500 (COMPARE:26 POSSIBLE:NAME:OF:CLASS:RELNS:22 ELEMENT:
75600 -RELNS:15)))))
75700 (COMPARE:19 redefined)
75800
75900
76000 \5Here begins one of the sections discussed on page 11 of this paper.\*
76100
76200 MOVE CURSOR TO ( JOIN:23 TYPE OF ( JOINING:FUNCTION))
76300 PUP: SORRY TO BOTHER YOU, BUT I CAN NO LONGER DEFER THIS PREDICATE DECIS
76400 -ION:(WHEN WE TERMINATE THE LOOP)
76500
76600 PLEASE TYPE IN A LOGICAL EXPRESSION WHICH IS TRUE ( WHEN WE TERMIN
76700 -ATE THE LOOP) AND IS FALSE OTHERWISE.
76800
76900 SHOULD I DISCUSS RAMIFICATIONS?\4NO\*
77000
77100 USER: \4(ANY RELATION IN POSSIBLE:NAME:OF:CLASS:RELNS:22 IS INCOMPATIBLE
77200 WITH ELEMENT:RELNS:15)\*
77300
77400 MOVE CURSOR TO JOIN:23
77500
77600
77700 PUP IS NOW GOING TO ENCODE THE PIECE
77800 (AND ARG1 ARG2 ARG3)
77900
78000
78100 OF THE FUNCTION JOIN:23 INTO LISP. FUNCTION NAMES WILL
78200 BE QUERIED IN PREORDER, AS NEEDED.
78300
78400 DRAW A LINE FROM THE FUNCTION CALL OF THE FUNCTION JOIN:23 TO THIS NEW PI
78500 -ECE OF CODE, WHICH IS ITS BODY:
78600
78700 (JOIN:23
78800 (LAMBDA (ARG1 ARG2 ARG3)
78900 (COMMENT IN ALL CALLS TO DATE, ARG1 IS INSTANTIATED AS
79000 COMPARE:24 POSSIBLE:NAME:OF:CLASS:OBJECTS:20 ELEMENT:OBJECTS:11))
79100 (COMMENT IN ALL CALLS TO DATE, ARG2 IS INSTANTIATED AS
79200 COMPARE:25 POSSIBLE:NAME:OF:CLASS:CLASSNAME:21 ELEMENT:CLASSNAME:13))
79300 (COMMENT IN ALL CALLS TO DATE, ARG3 IS INSTANTIATED AS
79400 COMPARE:26 POSSIBLE:NAME:OF:CLASS:RELNS:22 ELEMENT:RELNS:15))
79500
79600 (AND ARG1 ARG2 ARG3)))
79700 (JOIN:23 redefined)
79800
79900 (COMMENT POSSIBLE:NAME:OF:CLASS:OBJECTS:20 IS NOT A BEING YET)
80000 (COMMENT ELEMENT:OBJECTS:11 IS NOT A BEING YET)
80100
80200 .
80300 .
80400 .
80500 MOVE CURSOR TO ( COMPARE:26 TYPE OF ( COMPARE))
80600 PUP: SORRY TO BOTHER YOU, BUT I CAN NO LONGER DEFER THIS DICHOTOMY DECIS
80700 -ION:(( COMPARING MAY INVOLVE A FUNCTION
80800 APPLIED DIRECTLY TO THE TWO ARGUMENTS) ( COMPARING MAY INVOLVE APP
80900 -LYING A FUNCTION TO CORRESPONDING PAIRS OF
81000 SUBPARTS OF THE OBJECTS, AND FINALLY JOINING TOGETHER ALL THESE SUB-COMP
81100 -ARISONS' RESULTS) (ABOVE, A
81200 -RG1 REFERS TO POSSIBLE:NAME:OF:CLASS:RELNS:22
81300 ;ALSO, PLEASE IGNORE THE THIRD 'CHOICE'; IT IS ONLY FOR ME TO LOOK AT)
81400
81500 AHA!!!! I'VE RESOLVED IT MYSELF!!! NO NEED TO INTERACT WITH THE SLOW
81600 USER CHANNEL AFTER ALL!!!
81700
81800 MOVE CURSOR TO COMPARE:26
81900
82000
82100 PUP IS NOW GOING TO ENCODE THE PIECE
82200 (PROGN (COMMENT HERE WE MAY LATER WANT TO PUT SOME ASSIGNMENTS, REWRIT
82300 -ES, AND ITERATIVE STATEMENTS)
82400 (COND ((NOT (FORSOME RELATION IN POSSIBLE:NAME:OF:CLASS:RELNS:2
82500 -2 (RECOGNIZE:# RELATION ELEMENT:RELNS:15)))
82600 T)
82700 (T NIL)))
82800
82900
83000 OF THE FUNCTION COMPARE:26 INTO LISP. FUNCTION NAMES WILL
83100 BE QUERIED IN PREORDER, AS NEEDED.
83200
83300 PUP WANTS USER TO TYPE IN NAME FOR ( RECOGNIZE:#)
83400 I DON'T KNOW ANY NAMES FOR ( RECOGNIZE:#), SO YOU'LL HAVE TO
83500 TYPE A BRAND NEW NAME IN TO ME.
83600 USER: \4CONTRADICTS\*
83700
83800 THE NAME CHOSEN IS CONTRADICTS:27
83900
84000 MOVE CURSOR TO ( CONTRADICTS:27 TYPE OF ( RECOGNIZE:#))
84100 PUP: SORRY TO BOTHER YOU, BUT I CAN NO LONGER DEFER THIS SOMEOF DECISION
84200 :(PROBABILITY=1:# PROBABILITY=0:#
84300 PROBABILITY>0&<1:#)SINCE THE DECISION IS SOME:OF, TYPE ANY ORDERED SUBSE
84400 -T OF:
84500 (A .... PROBABILITY=1:#)
84600 (B .... PROBABILITY=0:#)
84700 (C .... PROBABILITY>0&<1:#)
84800
84900 USER: \4(A B C)\*
85000
85100
85200 (I RECOMMEND THAT POSSIBLE:NAME:OF:CLASS:RELNS:22 BE STRUCTURED INTO (AT
85300 LEAST ALONG ONE DIMENSION) THESE 3 PIECES:
85400 (PROBABILITY=1:#:PART:OF:POSSIBLE:NAME:OF:CLASS:RELNS:22 PROBABILITY=0:#
85500 :PART:OF:POSSIBLE:NAME:OF:CLASS:RELNS:22
85600 PROBABILITY>0&<1:#:PART:OF:POSSIBLE:NAME:OF:CLASS:RELNS:22) .PLEASE TYPE
85700 BACK YES, NO, OR UNSURE.)
85800
85900 USER: \4YES\*
86000
86100 PUP WANTS USER TO TYPE IN NAME FOR ( PROBABILITY:1:#:PART:OF:POSSI
86200 -BLE:NAME:OF:CLASS:RELNS)
86300
86400 I DON'T KNOW ANY NAMES FOR ( PROBABILITY:1:#:PART:OF:POSSIBLE:NAME
86500 :OF:CLASS:RELNS), SO YOU'LL HAVE TO
86600 TYPE A BRAND NEW NAME IN TO ME.
86700 USER: \4YES:RELNS\*
86800
86900 THE NAME CHOSEN IS YES:RELNS:28
87000
87100 PUP WANTS USER TO TYPE IN NAME FOR ( PROBABILITY:0:#:PART:OF:POSSI
87200 -BLE:NAME:OF:CLASS:RELNS)
87300 THE NAME CHOSEN IS NO:RELNS:29
87400
87500 PUP WANTS USER TO TYPE IN NAME FOR ( PROBABILITY>0&<1:#:PART:OF:PO
87600 -SSIBLE:NAME:OF:CLASS:RELNS)
87700 THE NAME CHOSEN IS MAYBE:RELNS:30
87800
87900
88000 DRAW A LINE FROM THE FUNCTION CALL (CONTRADICTS:27 RELATION ELEMENT:REL
88100 -NS:15) OF THE FUNCTION CONTRADICTS:27 TO THIS NEW PIECE OF CODE, WHICH
88200 IS ITS BODY:
88300
88400 (CONTRADICTS:27
88500 (LAMBDA (ARG1 ARG2)
88600 (COMMENT IN ALL CALLS TO DATE, ARG1 IS INSTANTIATED AS RELATION)
88700 (COMMENT IN ALL CALLS TO DATE, ARG2 IS INSTANTIATED AS ELEMENT:RELNS
88800 :15)
88900 (PROGN NIL
89000 (COND
89100 ((MEMBER ARG1 YES:RELNS:28)
89200 (PROGN (COMMENT ARG1 OCCURS WITH PROBABILITY 1, SO IT HAD
89300 BETTER BE
89400 IN ARG2, THE RELEVANT PIECE OF THE WORLD)
89500 (NOT (MEMBER ARG1 ARG2))))
89600 ((MEMBER ARG1 NO:RELNS:29)
89700 (PROGN (COMMENT SINCE ARG1 SHOULD NEVER OCCUR, WE HAVE A
89800 -CONTRADICTION
89900 IF IT IS A MEMBER OF
90000 -ARG2)
90100 (MEMBER ARG1 ARG2)))
90200 (T (PROGN (COMMENT WE MAY OR MAY NOT HAVE ARG1 IN ARG2; EIT
90300 -HER CASE IS ALLOWABLE; SO WE
90400 NEVER HAVE A CONTRADICTION)
90500 NIL))))))
90600 (CONTRADICTS:27 redefined)
90700
90800 PUP: (PUP WORKED ON SOMETHING IMPROBABLE, NAMELY (IN ALL CODE GENERATED,
90900 POSSIBLE:NAME:OF:CLASS:RELNS:22 SHOULD BE
91000 REPLACED BY (APPEND YES:RELNS:28 NO:RELNS:29 MAYBE:RELNS:30)) ,AND HERE
91100 -IS WHAT WE FINALLY DID ABOUT IT: (WE REPLACED
91200 ALL OCCURRENCES OF POSSIBLE:NAME:OF:CLASS:RELNS:22 BY (APPEND YES:RELNS:
91300 -28 NO:RELNS:29 MAYBE:RELNS:30)))
91400
91500
91600 MOVE CURSOR TO ( MODIFY:STRUCTURE:7 TYPE OF ( MODIFY:STRUCTU
91700 -RE))
91800 PUP: SORRY TO BOTHER YOU, BUT I CAN NO LONGER DEFER THIS SUBSETOF DECISI
91900 -ON:(CONDITIONAL:INSERTION CONDITIONAL:DELETION
92000 COMPLEX:ALTERATION)SINCE THE DECISION IS SUBSET:OF, TYPE ANY ORDERED SUB
92100 -SET OF:
92200 (A .... CONDITIONAL:INSERTION)
92300 (B .... CONDITIONAL:DELETION)
92400 (C .... COMPLEX:ALTERATION)
92500
92600 USER: \4(A C)\*
92700
92800 DRAW A LINE FROM THE FUNCTION CALL (MODIFY:STRUCTURE:7 NAME:OF:CLASS) O
92900 -F THE FUNCTION MODIFY:STRUCTURE:7 TO THIS NEW PIECE OF CODE, WHICH IS
93000 -ITS BODY:
93100
93200 (MODIFY:STRUCTURE:7
93300 (LAMBDA (ARG1)
93400 (COMMENT IN ALL CALLS TO DATE, ARG1 IS INSTANTIATED AS NAME:OF:CLASS
93500 )
93600 (COMMENT IN ALL CALLS TO DATE, ARG2 IS INSTANTIATED AS NIL)
93700 (PROGN (CONDITIONAL:INSERTION:31 ARG1 ARG2)
93800 (COMPLEX:ALTERATION:32 ARG1 ARG2))))
93900 (MODIFY:STRUCTURE:7 redefined)
94000
94100
94200 I HAVE DECIDED TO KEEP POSSIBLE:NAME:OF:CLASS STRUCTURED USING THE PROPE
94300 -RTY LIST
94400 FEATURE OF LISP. FOR THIS REASON, I NEED TO HAVE A NAME FOR EACH
94500 PROPERTY (CORRESPONDING TO EACH SUBPART OF POSSIBLE:NAME:OF:CLASS) :
94600
94700 \5<This is the end of the example fragments of dialogue>\*